package com.wusiwei.service.impl;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;
import com.wusiwei.entity.DeepSeekRequest;
import com.wusiwei.service.AIService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * AI服务实现类
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class AIServiceImpl implements AIService {

    private final Gson gson = new Gson();
    @Value("${ai.api.key}")
    private String apiKey;
    @Value("${ai.api.url}")
    private String apiUrl;

    /**
     * 检查商品明细是否兼容
     * 判断多个商品明细是否可以组成一个完整产品
     *
     * @param sourceItemName  源商品名称（如：电脑）
     * @param targetItemNames 目标商品名称列表（如：显示器、主机、键盘鼠标）
     * @return 是否兼容
     */
    @Override
    public boolean checkItemsCompatibility(String sourceItemName, List<String> targetItemNames) {
        try {
            log.info("调用AI接口检查商品兼容性, 源商品: {}, 目标商品: {}", sourceItemName, targetItemNames);

            // 设置Unirest超时
            Unirest.setTimeouts(0, 0);

            // 构建prompt
            String prompt = buildPrompt(sourceItemName, targetItemNames);
            log.debug("构建的AI提示词: {}", prompt);

            // 准备消息列表
            List<DeepSeekRequest.Message> messages = new ArrayList<>();
            messages.add(DeepSeekRequest.Message.builder()
                    .role("system")
                    .content("你是一个组装专家，我会给你一些零件和一个成品，请你判断零件是否能组装成为我提供的成品，请你只用一个数字回答，0-100，100为最接近")
                    .build());

            messages.add(DeepSeekRequest.Message.builder()
                    .role("user")
                    .content(prompt)
                    .build());

            // 构建请求体
            DeepSeekRequest requestBody = DeepSeekRequest.builder()
                    .model("deepseek-chat")
                    .messages(messages)
                    .build();

            log.debug("发送请求到AI API: {}", apiUrl);

            // 发送请求
            HttpResponse<String> response = Unirest.post(apiUrl)
                    .header("Content-Type", "application/json")
                    .header("Accept", "application/json")
                    .header("Authorization", apiKey)
                    .body(gson.toJson(requestBody))
                    .asString();

            // 记录原始响应，便于调试
            log.debug("AI API 原始响应: {}", response.getBody());

            // 检查HTTP状态码
            if (response.getStatus() != 200) {
                log.error("AI API 请求失败, 状态码: {}, 响应内容: {}", response.getStatus(), response.getBody());
                return false;
            }

            // 解析响应
            JsonObject jsonResponse = gson.fromJson(response.getBody(), JsonObject.class);

            // 安全地获取响应内容
            String aiResponse = extractResponseContent(jsonResponse);

            // 如果无法提取到有效响应内容
            if (aiResponse == null || aiResponse.isEmpty()) {
                log.error("无法从AI响应中提取内容: {}", response.getBody());
                return false;
            }

            log.info("AI接口返回结果: {}", aiResponse);

            // 解析分数
            int score = parseScore(aiResponse);
            log.info("解析出的AI评分: {}", score);

            // 设置兼容性阈值，大于等于80分认为是兼容的
            boolean compatible = score >= 80;

            log.info("兼容性判断结果: {}, 分数: {}", compatible, score);
            return compatible;

        } catch (Exception e) {
            log.error("调用AI接口检查商品兼容性失败: {}", e.getMessage(), e);
            return false;
        }
    }

    /**
     * 安全地从JSON响应中提取内容文本
     */
    private String extractResponseContent(JsonObject jsonResponse) {
        try {
            if (jsonResponse == null) {
                return null;
            }

            // 尝试标准格式
            if (jsonResponse.has("choices")) {
                JsonArray choices = jsonResponse.getAsJsonArray("choices");
                if (choices != null && !choices.isEmpty()) {
                    JsonObject choice = choices.get(0).getAsJsonObject();
                    if (choice.has("message")) {
                        JsonObject message = choice.getAsJsonObject("message");
                        if (message.has("content")) {
                            return message.get("content").getAsString();
                        }
                    }
                }
            }

            // 尝试替代格式
            if (jsonResponse.has("content")) {
                return jsonResponse.get("content").getAsString();
            }

            // 尝试直接获取文本响应
            if (jsonResponse.has("text") || jsonResponse.has("response")) {
                String key = jsonResponse.has("text") ? "text" : "response";
                return jsonResponse.get(key).getAsString();
            }

            // 遍历所有字段，寻找可能的文本内容
            for (String key : jsonResponse.keySet()) {
                JsonElement element = jsonResponse.get(key);
                if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isString()) {
                    String value = element.getAsString();
                    // 如果字段内容看起来像数字或评分，直接返回
                    if (value.matches("\\d+")) {
                        return value;
                    }
                }
            }

            // 如果所有尝试都失败，返回整个JSON字符串
            return jsonResponse.toString();
        } catch (Exception e) {
            log.warn("解析AI响应内容失败: {}", e.getMessage());
            return null;
        }
    }

    /**
     * 构建提示词
     */
    private String buildPrompt(String sourceItemName, List<String> targetItemNames) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("成品: ").append(sourceItemName).append("\n");
        prompt.append("零件: ");

        for (int i = 0; i < targetItemNames.size(); i++) {
            prompt.append(targetItemNames.get(i));
            if (i < targetItemNames.size() - 1) {
                prompt.append("、");
            }
        }

        prompt.append("\n请给出零件能组装成成品的可能性评分(0-100)，只需回复数字，无需解释。");
        return prompt.toString();
    }

    /**
     * 解析AI返回的分数
     */
    private int parseScore(String aiResponse) {
        try {
            // 尝试直接解析整个响应为数字
            String cleaned = aiResponse.trim();
            log.debug("尝试解析分数，原始响应: '{}'", cleaned);

            try {
                return Integer.parseInt(cleaned);
            } catch (NumberFormatException e) {
                log.debug("直接解析为整数失败，尝试提取数字: {}", e.getMessage());
            }

            // 如果无法直接解析，尝试从文本中提取数字
            String[] words = aiResponse.split("\\s+");
            for (String word : words) {
                // 去除非数字字符
                String numberOnly = word.replaceAll("[^0-9]", "");
                if (!numberOnly.isEmpty()) {
                    try {
                        int score = Integer.parseInt(numberOnly);
                        log.debug("从文本中提取到分数: {}", score);
                        return score;
                    } catch (NumberFormatException ex) {
                        // 继续尝试下一个单词
                        log.debug("无法解析为数字: {}", numberOnly);
                    }
                }
            }

            // 如果是关键词，可能表示高度兼容
            if (aiResponse.toLowerCase().contains("完全兼容") ||
                    aiResponse.toLowerCase().contains("100%") ||
                    aiResponse.toLowerCase().contains("非常高")) {
                log.info("找到高度兼容的关键词，返回分数100");
                return 100;
            }

            // 如果没有找到有效数字，设置默认值
            log.warn("无法从AI响应中解析分数: {}", aiResponse);
            return 0;
        } catch (Exception e) {
            log.error("解析分数时发生异常: {}", e.getMessage());
            return 0;
        }
    }
} 